import { Component, error } from "cc";
import { UIViewFieldPath } from "./UIViewFieldPath";

export enum SearchType{
    Single,//单个节点
    Children,//
    // Descendants
}

/**
 * 功能1：根据路径查找指定的Node节点或组件
 * 功能2：查找指定路径节点下的孩子里的组件或后代里的组件
 * 查找节点时，type不传
 * 查找组件时：
 * 1.type必填
 * 2.如果searchType不填，默认是找路径对应的节点上的组件
 * 3.如果searchType是children，则是找路径节点的所有孩子节点上的组件
//  * 4.如果searchType是Descendants，则是找路径节点的所有后代节点上的组件
 * @param path 
 * @param type 
 * @param searchType 
 * @returns 
 */
// 自动绑定控件节点（装饰器）
export function bindNode<T extends Component>(path: string,type?:new(...args:any[])=>T,searchType:SearchType = SearchType.Single) {
    return (target: any, propertyKey: string) => {
        let pathKey = target.name+"_"+propertyKey
        if(!UIViewFieldPath.bindMetas.has(pathKey)){
            let bindMeta = {
                path,
                type:type?type:null,
                searchType
            }
            UIViewFieldPath.bindMetas.set(pathKey,bindMeta)
        }
        // target["__path_"+propertyKey] = path
        // const descriptorOld = Object.getOwnPropertyDescriptor(target, propertyKey);
        // // target.prototype[""]
        // let descriptor = {
        //     get: function() {
        //         let key = propertyKey+"_v"
        //         if(this[key]){
        //             return this[key]
        //         }
        //         let find =  this.node.getChildByPath(path);
        //         if(find){
        //             this[key] = find
        //             return find
        //         }
        //         throw new Error("未找到路径对应的节点："+(this as Component).name+"  "+path)
        //     },
        // };
        // Object.defineProperty(target, propertyKey, descriptor);
    };
}

// 自动绑定事件（装饰器）
// export function bindEvent(eventType: string, path: string) {
//     return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
//         const method = descriptor.value;
//         descriptor.value = function (this: BaseView) {
//             const node = this.node.getChildByPath(path);
//             if (node) {
//                 node.on(eventType, method, this);
//             } else {
//                 error(`Node not found: ${path}`);
//             }
//         };
//     };
// }
export function uiview(){
    return function <T extends { new(...args: any[]): {} }>(constructor: T) {
        return class extends constructor {
            constructor(...args: any[]) {
                super(...args);
    
                // 获取类的所有实例属性
                const propertyNames = Object.getOwnPropertyNames(this);
    
                // 为每个属性添加 getter
                propertyNames.forEach((propertyName) => {
                    if (propertyName !== 'constructor') { // 排除构造函数

                        let nodePath = constructor["__path_"+propertyName] || constructor.prototype["__path_"+propertyName]
                        if(nodePath){
                            this["__v_"+propertyName] = this["node"].getChildByPath(nodePath);
                            if(!this["__v_"+propertyName]){
                                throw new error(constructor.name+" not found node in path:"+nodePath)
                            }

                        }
                    }
                });
            }
        };
    }
}
